package com.yaozheng.vocationaltraining.activity;

import java.io.Serializable;

import com.bumptech.glide.Glide;
import com.yaozheng.vocationaltraining.R;
import com.yaozheng.vocationaltraining.dialog.ask.CancelAskDialog;
import com.yaozheng.vocationaltraining.dialog.ask.ConfirmCancelAskDialog;
import com.yaozheng.vocationaltraining.utils.BitmapLoader;
import com.yaozheng.vocationaltraining.utils.Constants;
import com.yaozheng.vocationaltraining.utils.ErrorUtils;
import com.yaozheng.vocationaltraining.utils.JudgeUtils;

import android.app.ProgressDialog;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.SharedPreferences;
import android.content.DialogInterface.OnCancelListener;
import android.content.SharedPreferences.Editor;
import android.os.Bundle;
import android.os.Environment;
import android.os.IBinder;
import android.os.PersistableBundle;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentActivity;
import android.support.v4.app.FragmentManager;
import android.support.v4.app.FragmentTransaction;
import android.view.MotionEvent;
import android.view.View;
import android.view.inputmethod.InputMethodManager;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;

import cn.jpush.android.api.JPushInterface;

/**
 * BaseActivity
 *
 * @author Administrator
 */
public class BaseActivity extends FragmentActivity implements OnCancelListener {


    protected ProgressDialog progressDialog;
    /**
     * 得到会话令牌，用于区分登录用户
     */
    private String token, userId;

    private BitmapLoader defaultBitmapLoader;

    private ConfirmCancelAskDialog confirmCancelAskDialog;

    private CancelAskDialog cancelAskDialog;

    protected BroadcastReceiver activityInternalReceiver;


    public ProgressDialog getProgressDialog() {
        return progressDialog;
    }


    /**
     * 得到默认图片加载
     *
     * @return
     */
    public BitmapLoader getDefaultBitmapLoader() {
        if (defaultBitmapLoader == null) {
            defaultBitmapLoader = new BitmapLoader(Glide.with(this), R.drawable.default_load_image);
        }
        return defaultBitmapLoader;
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        registerActivityInternalReceiver();
    }

    /**
     * 注册自定义广播
     */
    protected void registerActivityInternalReceiver() {
        IntentFilter intentFilter = new IntentFilter();

        if (addBroadcastAction(intentFilter)) {
            activityInternalReceiver = new BroadcastReceiver() {
                public void onReceive(Context context, Intent intent) {
                    BaseActivity.this.onReceive(context, intent);
                }
            };

        }
        if (activityInternalReceiver != null) {
            registerReceiver(activityInternalReceiver, intentFilter);
        }
    }

    /**
     * 添加关闭action
     *
     * @param intentFilter
     * @return false不注册广播
     */
    protected boolean addBroadcastAction(IntentFilter intentFilter) {
        intentFilter.addAction(Constants.EXIT_ACTIVITYS_ACTION);
        return true;
    }

    /**
     * 注销广播
     */
    protected void unregisterActivityInternalReceiver() {
        if (activityInternalReceiver != null) {
            unregisterReceiver(activityInternalReceiver);
        }
    }

    public void onReceive(Context context, Intent intent) {

        if (Constants.EXIT_ACTIVITYS_ACTION.equals(intent.getAction())) {
            finish();
        }
    }

    /**
     * 显示带进度条的对话框
     *
     * @param message 根据当前message显示到进度条上面
     */
    public void showProgressDialog(String message) {

        if (progressDialog == null) {
            progressDialog = this.getProgressDialog(message);
        } else {
            this.progressDialog.setMessage(message);
        }
        progressDialog.show();
    }

    /**
     * 创建进度条的对话框
     *
     * @param message 根据message生成一个带进度条的对话框
     * @return 返回一个带进度条的对话框
     */
    protected ProgressDialog getProgressDialog(String message) {
        return JudgeUtils.getRoundProgressDialog(message, this, this);

    }

    /**
     * 提示消息
     *
     * @param reId
     */
    public void alertMessage(int reId) {
        alertMessage(getString(reId));
    }

    /**
     * 得到标题TextView
     *
     * @return
     */
    public TextView getTitleTextView() {
        return (TextView) findViewById(R.id.headTitleText);
    }

    /**
     * 设置标题
     */
    public void setHeadTitle(String title) {
        TextView titleTextView = getTitleTextView();
        if (titleTextView != null) {
            titleTextView.setText(title);
        }
    }

    /**
     * right隐藏
     */
    public void rightShow() {
        View view = findViewById(R.id.headRightImage);
        if (view != null) {
            view.setVisibility(View.VISIBLE);
        }
    }

    /**
     * 提示消息
     *
     * @param message
     */
    public void alertMessage(String message) {
        if (message != null) {
            Toast.makeText(this, message, Toast.LENGTH_LONG).show();
        }
    }

    /**
     * 反射点击事件 处理
     *
     * @param view 当前添加的对象
     */
    public void reflexRunClick(View view) {
        Object tag = view.getTag();
        if (tag == null)
            return;
        reflexRunClick(tag.toString());
    }

    /**
     * 反射点击事件 处理
     *
     * @param runMethod 运行方法
     */
    public void reflexRunClick(String runMethod) {
        try {
            getClass().getMethod(runMethod, new Class[0]).invoke(this, new Object[0]);
        } catch (Exception e) {
            ErrorUtils.outErrorLog(e);
        }
    }

    /**
     * Fragment底部点击
     *
     * @param view
     */
    public void reflexRunFragmentClick(View view) {
        Object tag = view.getTag();
        if (tag == null)
            return;
        reflexRunFragmentClick(tag.toString());
    }

    /**
     * Fragment点击
     */
    public void reflexRunFragmentClick(String runMethod) {
        reflexRunClick(runMethod);
    }

    /**
     * 隐藏键盘
     */

    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        boolean returnBoolena = super.dispatchTouchEvent(ev);
        if (ev.getAction() == MotionEvent.ACTION_DOWN) {
            // 获得当前得到焦点的View，一般情况下就是EditText（特殊情况就是轨迹求或者实体案件会移动焦点）
            View v = getCurrentFocus();

            if (isShouldHideInput(v, ev)) {
                hideSoftInput(v.getWindowToken());
            }
        }
        return returnBoolena;
    }

    /**
     * 根据EditText所在坐标和用户点击的坐标相对比，来判断是否隐藏键盘，因为当用户点击EditText时没必要隐藏
     *
     * @param v
     * @param event
     * @return
     */
    private boolean isShouldHideInput(View v, MotionEvent event) {
        if (v != null && (v instanceof EditText)) {
            int[] l = {0, 0};
            v.getLocationInWindow(l);
            int left = l[0], top = l[1], bottom = top + v.getHeight(), right = left
                    + v.getWidth();
            if (event.getX() > left && event.getX() < right
                    && event.getY() > top && event.getY() < bottom) {
                // 点击EditText的事件，忽略它。
                return false;
            } else {
                return true;
            }
        }
        // 如果焦点不是EditText则忽略，这个发生在视图刚绘制完，第一个焦点不在EditView上，和用户用轨迹球选择其他的焦点
        return false;
    }

    /**
     * 多种隐藏软件盘方法的其中一种
     *
     * @param token
     */
    protected void hideSoftInput(IBinder token) {
        if (token != null) {
            InputMethodManager im = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
            im.hideSoftInputFromWindow(token,
                    InputMethodManager.HIDE_NOT_ALWAYS);
        }
    }

    /**
     * 返回点击
     */
    public void backClick() {
        onBackPressed();
    }

    /**
     * 显示当前碎片
     *
     * @param fragment
     * @param isAddBack 是否添加到back
     */
    public void showCurrFragment(Fragment fragment, boolean isAddBack) {
        if (fragment != null && !fragment.isVisible()) {
            FragmentManager fm = getSupportFragmentManager();
            FragmentTransaction transaction = fm.beginTransaction();

            if (!fragment.isAdded()) {
                transaction.replace(R.id.contentFragment, fragment);

            } else {
                transaction.show(fragment);
            }
            if (isAddBack) {
                transaction.addToBackStack(null);
            } else {
                int num = fm.getBackStackEntryCount();
                for (int i = 0; i < num; i++) {
                    fm.popBackStackImmediate();
                }
            }
            transaction.commit();
        }
    }

    /**
     * 显示当前碎片
     *
     * @param fragment
     */
    public void showCurrFragment(Fragment fragment) {
        showCurrFragment(fragment, false);
    }

    @Override
    public void onCancel(DialogInterface dialog) {

    }

    /**
     * 取消进度条
     */
    public void cancelProgressDialog() {
        if (progressDialog != null && progressDialog.isShowing()) {
            progressDialog.cancel();
        }
    }

    /**
     * 得到Intent中的String
     *
     * @param name intent对应key
     * @return 返回intent对应name的值
     */
    public String getIntentString(String name) {
        return getIntent().getStringExtra(name);
    }

    /**
     * 得到Intent中的int
     *
     * @param name intent对应key
     * @return 返回intent对应name的int值
     */
    public int getIntentInt(String name) {
        return getIntent().getIntExtra(name, -1);
    }

    /**
     * 得到Intent中的int
     *
     * @param name         到intent中得到String
     * @param defaultValue 默认值
     * @return 返回intent对应name的int值
     */
    public int getIntentInt(String name, int defaultValue) {
        return getIntent().getIntExtra(name, defaultValue);
    }

    /**
     * 得到Intent中的long
     *
     * @param name intent对应key
     * @return 返回intent对应name的long值
     */
    public long getIntentLong(String name) {
        return getIntentLong(name, -1L);
    }

    /**
     * 得到Intent中的long
     *
     * @param name         intent对应key
     * @param defaultValue 默认值
     * @return 返回intent对应name的long值
     */
    public long getIntentLong(String name, long defaultValue) {
        return getIntent().getLongExtra(name, defaultValue);
    }

    /**
     * @param name  设置到intent
     * @param value 值
     */
    public void setIntentLong(String name, long value) {
        getIntent().putExtra(name, value);
    }

    /**
     * 得到Intent中的Serializable
     *
     * @param name 到intent中得到String
     * @return 返回intent对应name的Serializable值
     */
    public Serializable getIntentSerializable(String name) {
        return getIntent().getSerializableExtra(name);
    }

    /**
     * 设置value到Intent中
     *
     * @param name  保存名称
     * @param value 需要设置到intent中的值
     */
    public void setIntentString(String name, String value) {
        getIntent().putExtra(name, value);

    }

    /**
     * 设置value到Intent中
     *
     * @param name  保存名称
     * @param value 需要设置到intent中的值
     */
    public void setIntentBoolean(String name, boolean value) {
        getIntent().putExtra(name, value);

    }

    /**
     * 设置value到Intent中
     *
     * @param name 保存名称
     */
    public boolean getIntentBoolean(String name) {
        return getIntentBoolean(name, false);

    }

    /**
     * 设置value到Intent中
     *
     * @param name         保存名称
     * @param defaultValue 默认值
     */
    public boolean getIntentBoolean(String name, boolean defaultValue) {
        return getIntent().getBooleanExtra(name, defaultValue);

    }

    /**
     * 设置int到Intent中
     *
     * @param name  保存名称
     * @param value 需要设置到intent中的值
     */
    public void setIntentInt(String name, int value) {
        getIntent().putExtra(name, value);

    }

    /**
     * 设置float到Intent中
     *
     * @param name  保存名称
     * @param value 需要设置到intent中的值
     */
    public void setIntentFloat(String name, float value) {
        getIntent().putExtra(name, value);

    }

    /**
     * 得到Intent中的float
     *
     * @param name         保存名称
     * @param defaultValue 默认值
     * @return 返回intent对应name的float值
     */
    public float getIntentFloat(String name, float defaultValue) {
        return getIntent().getFloatExtra(name, defaultValue);
    }

    /**
     * 得到Intent中的float
     *
     * @param name 保存名称
     * @return 返回intent对应name的float值
     */
    public double getIntentDouble(String name) {
        return getIntentDouble(name, 0);
    }

    /**
     * 设置float到Intent中
     *
     * @param name  保存名称
     * @param value 需要设置到intent中的值
     */
    public void setIntentDouble(String name, double value) {
        getIntent().putExtra(name, value);

    }

    /**
     * 得到Intent中的float
     *
     * @param name         保存名称
     * @param defaultValue 默认值
     * @return 返回intent对应name的float值
     */
    public double getIntentDouble(String name, double defaultValue) {
        return getIntent().getDoubleExtra(name, defaultValue);
    }

    /**
     * 得到Intent中的float
     *
     * @param name 保存名称
     * @return 返回intent对应name的float值
     */
    public float getIntentFloat(String name) {
        return getIntentFloat(name, 0);
    }

    /**
     * 设置serializable到Intent中
     *
     * @param name         到intent中得到String
     * @param serializable 需要设置到intent中的值
     */
    public void setIntentSerializable(String name, Serializable serializable) {
        getIntent().putExtra(name, serializable);
    }

    /**
     * 移除Intent中的数据
     *
     * @param name 名称
     */
    public void removeIntentData(String name) {
        getIntent().removeExtra(name);
    }

    /**
     * 读取SharedPreFerences中需要的数据
     *
     * @return 返回一个能操作共享数据的接口
     */
    public SharedPreferences getSharedPreferences() {
        return getSharedPreferences("vocationaltrainingdata", MODE_PRIVATE);
    }

    /**
     * 得到用户分享目录
     *
     * @return
     */
    public SharedPreferences getCurrUserSharedPreferences() {
        return getSharedPreferences(getToken(), MODE_PRIVATE);
    }

    /**
     * 得到会话令牌，用于区分登录用户
     */
    public String getToken() {
        if (token == null) {
            token = getIntentString("token");
            if (token == null) {
                token = getSharedPreferences().getString("token", null);
                setIntentString("token", token);
            }
        }
        return token;
    }

    /**
     * 得到userId
     *
     * @return
     */
    public String getUserId() {
        if (userId == null) {
            userId = getIntentString("userId");
            if (userId == null) {
                userId = getSharedPreferences().getString("userId", null);
                setIntentString("userId", userId);
            }
        }
        return userId;
    }

    /**
     * 设置Token
     *
     * @param userId
     */
    public void setUserId(String userId) {
        if (token == null) {
            if (isLogin()) {
                Editor editor = getSharedPreferences().edit();
                editor.remove("userId");
                editor.commit();
            }
            return;
        }
        if (!userId.equals(this.userId)) {
            setIntentString("userId", userId);
            Editor editor = getSharedPreferences().edit();
            editor.putString("userId", userId);
            editor.commit();
        }
    }

    /**
     * token 失效
     */
    public void tokenFail() {
        signOutOperating();
    }

    /**
     * 设置Token
     *
     * @param token
     */
    public void setToken(String token) {
        if (token == null) {
            if (isLogin()) {
                Editor editor = getSharedPreferences().edit();
                editor.remove("token");
                editor.commit();
            }
            return;
        }
        if (!token.equals(this.token)) {
            setIntentString("token", token);
            Editor editor = getSharedPreferences().edit();
            editor.putString("token", token);
            editor.commit();
        }
    }

    /**
     * 显示加载数据进度条
     */
    public void showLoadDataProgressDialog() {

    }

    /**
     * 取消加载数据进度条
     */
    public void cancelLoadDataProgressDialog() {

    }

    /**
     * 显示加载数据进度条
     */
    public void showOperatingProgressDialog(String message) {
        showProgressDialog(message);
    }

    /**
     * 取消操作进度条
     */
    public void cancelOperatingProgressDialog() {
        cancelProgressDialog();
    }

    /**
     * 得到资源保存路径
     *
     * @return 返回资源存放路径
     */
    public String getResourcesCachePath() {
        boolean sdCardExist = Environment.getExternalStorageState().equals(
                Environment.MEDIA_MOUNTED); // 判断sd卡是否存在
        if (sdCardExist) {
            return Environment.getExternalStorageDirectory().toString();// 获取跟目录
        }
        return "";
    }

    /**
     * 是否登录
     *
     * @return true登录过 false没登录
     */
    public boolean isLogin() {
        // return false;
        return getToken() != null;
    }

    public boolean isResponseResult() {
        return !isFinishing();
    }


    public void runMethod(String methodName) {
        try {
            getSubClasses().getMethod(String.valueOf(methodName), new Class[0]).invoke(
                    getSubObject(), new Object[]{});
        } catch (Exception e) {
            e.printStackTrace();
            error(e);
        }
    }

    public void error(Exception e) {
    }

    /**
     * 得到子类class
     *
     * @return
     */
    public Class getSubClasses() {
        return getClass();
    }

    /**
     * 得到子类对象
     *
     * @return
     */
    public Object getSubObject() {
        return this;
    }

    /**
     * 显示确认取消对话框
     */
    public void showConfirmCancelAskDialog(String messageContent) {
        showConfirmCancelAskDialog(messageContent, "confirmCancelAskDialogDetermineClick");
    }

    protected void onResume() {
        super.onResume();
        JPushInterface.onResume(this);
    }

    protected void onPause() {
        super.onPause();
        JPushInterface.onPause(this);
    }

    /**
     * 显示确认取消对话框
     *
     * @param messageContent 消息内容
     * @param runMethod      运行方法
     */
    public void showConfirmCancelAskDialog(String messageContent, String runMethod) {
        showConfirmCancelAskDialog(messageContent, "请选择", runMethod);
    }

    /**
     * 显示确认取消对话框
     *
     * @param messageContent 消息内容
     * @param title          ==null 隐藏
     * @param runMethod      运行方法
     */
    public void showConfirmCancelAskDialog(String messageContent, String title, String runMethod) {
        if (confirmCancelAskDialog == null) {
            confirmCancelAskDialog = new ConfirmCancelAskDialog(this);
        }
        confirmCancelAskDialog.show();
        confirmCancelAskDialog.setContent(messageContent, title);
        confirmCancelAskDialog.setRunMethod(runMethod);
    }

    /**
     * 显示带确定对话
     *
     * @param messageContent 消息内容
     * @param titileValue    标题
     * @param runMethod      运行方法
     */
    public void showCancelAskDialog(String messageContent, String titileValue, String runMethod) {
        if (cancelAskDialog == null) {
            cancelAskDialog = new CancelAskDialog(this);
        }
        cancelAskDialog.show();
        cancelAskDialog.setContentValue(messageContent);
        cancelAskDialog.setTitileValue(titileValue);
        cancelAskDialog.runMethod(runMethod);
    }

    /**
     * 显示带取消对话框
     *
     * @param messageContent
     * @param runMethod
     */
    public void showCancelAskDialog(String messageContent, String runMethod) {
        showCancelAskDialog(messageContent, "提示", runMethod);
    }

    /**
     * 确定取消 询问对话确定点击
     */
    public void confirmCancelAskDialogDetermineClick() {

    }


    /**
     * 退出操作
     */
    public void signOutOperating() {
        token = null;
        removeIntentData("token");
        Editor editor = getSharedPreferences().edit();
        editor.remove("token");
        editor.commit();
        Intent exitActivity = new Intent();
        exitActivity.setAction(Constants.EXIT_ACTIVITYS_ACTION);
        sendBroadcast(exitActivity);
        Intent intent = new Intent();
        intent.setClassName(this, Constants.LOGIN_CLASS_NAME);
        startActivity(intent);
        finish();
    }

    @Override
    protected void onDestroy() {
        unregisterActivityInternalReceiver();
        cancelProgressDialog();
        if (confirmCancelAskDialog != null && confirmCancelAskDialog.isShowing()) {
            confirmCancelAskDialog.cancel();
        }
        if (cancelAskDialog != null && cancelAskDialog.isShowing()) {
            cancelAskDialog.cancel();
        }
        super.onDestroy();
    }

}
